package server

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/pem"
	"fmt"
	"log"
	"math/big"
	"net/http"
	"os"
	"path/filepath"
	"reflect"
	"runtime"
	"time"

	"github.com/babytap/server/internal/api"
	"github.com/babytap/server/internal/database"
	"github.com/gofiber/fiber/v2"
	"github.com/gofiber/fiber/v2/middleware/cors"
	"github.com/gofiber/fiber/v2/middleware/logger"
	"github.com/gofiber/fiber/v2/middleware/recover"
)

// HTTPSServer HTTPS 服务器
type HTTPSServer struct {
	port    int
	DataDir string
	repo    *database.CardRepository
	handler *api.CardHandler
	app     *fiber.App
	server  *http.Server
	// 性能监控
	startTime time.Time
	stats     *ServerStats
	// UDP 发现服务引用
	udpDiscovery interface{}
}

// ServerStats 服务器统计信息
type ServerStats struct {
	StartTime    time.Time
	RequestCount int64
	ErrorCount   int64
	MemoryUsage  uint64
	Uptime       time.Duration
}

// NewHTTPSServer 创建新的 HTTPS 服务器
func NewHTTPSServer(port int, dataDir string) (*HTTPSServer, error) {
	startTime := time.Now()

	// 创建数据目录
	if err := os.MkdirAll(dataDir, 0755); err != nil {
		return nil, fmt.Errorf("创建数据目录失败: %w", err)
	}

	// 初始化数据库
	repo, err := database.NewCardRepository(dataDir)
	if err != nil {
		return nil, fmt.Errorf("初始化数据库失败: %w", err)
	}

	// 创建处理器
	handler := api.NewCardHandler(repo)

	server := &HTTPSServer{
		port:      port,
		DataDir:   dataDir,
		repo:      repo,
		handler:   handler,
		startTime: startTime,
		stats: &ServerStats{
			StartTime: startTime,
		},
	}

	// 启动性能监控
	go server.monitorPerformance()

	return server, nil
}

// NewHTTPSServerWithUDPDiscovery 创建新的 HTTPS 服务器（带UDP发现服务）
func NewHTTPSServerWithUDPDiscovery(port int, dataDir string, udpDiscovery interface{}) (*HTTPSServer, error) {
	startTime := time.Now()

	// 创建数据目录
	if err := os.MkdirAll(dataDir, 0755); err != nil {
		return nil, fmt.Errorf("创建数据目录失败: %w", err)
	}

	// 初始化数据库
	repo, err := database.NewCardRepository(dataDir)
	if err != nil {
		return nil, fmt.Errorf("初始化数据库失败: %w", err)
	}

	// 创建处理器（带UDP发现服务）
	handler := api.NewCardHandlerWithUDPDiscovery(repo, udpDiscovery)

	server := &HTTPSServer{
		port:         port,
		DataDir:      dataDir,
		repo:         repo,
		handler:      handler,
		startTime:    startTime,
		udpDiscovery: udpDiscovery,
		stats: &ServerStats{
			StartTime: startTime,
		},
	}

	// 启动性能监控
	go server.monitorPerformance()

	return server, nil
}

// Start 启动服务器
func (s *HTTPSServer) Start() error {
	// 创建 Fiber 应用
	app := fiber.New(fiber.Config{
		AppName:      "Baby Tap API Server",
		ServerHeader: "BabyTap",
		// 性能优化配置
		ReadTimeout:  30 * time.Second,
		WriteTimeout: 30 * time.Second,
		IdleTimeout:  120 * time.Second,
		// 连接池配置
		DisableStartupMessage: true,
		ErrorHandler: func(c *fiber.Ctx, err error) error {
			code := fiber.StatusInternalServerError
			if e, ok := err.(*fiber.Error); ok {
				code = e.Code
			}
			// 统计错误
			s.stats.ErrorCount++
			return c.Status(code).JSON(fiber.Map{
				"code": code,
				"data": err.Error(),
			})
		},
	})

	// 添加中间件
	app.Use(logger.New(logger.Config{
		Format:     "[${time}] ${status} - ${method} ${path} - ${latency}\n",
		TimeFormat: "2006-01-02 15:04:05",
		Output:     os.Stdout,
	}))
	app.Use(recover.New())
	app.Use(cors.New(cors.Config{
		AllowOrigins: "*",
		AllowMethods: "GET,POST,PUT,DELETE,OPTIONS",
		AllowHeaders: "Content-Type,Authorization",
	}))

	// 请求统计中间件
	app.Use(func(c *fiber.Ctx) error {
		s.stats.RequestCount++
		return c.Next()
	})

	// 注册卡片路由
	s.handler.RegisterRoutes(app)

	// 性能监控路由
	app.Get("/stats", func(c *fiber.Ctx) error {
		var m runtime.MemStats
		runtime.ReadMemStats(&m)
		s.stats.MemoryUsage = m.Alloc
		s.stats.Uptime = time.Since(s.stats.StartTime)

		return c.JSON(fiber.Map{
			"code": 0,
			"data": fiber.Map{
				"uptime":        s.stats.Uptime.String(),
				"request_count": s.stats.RequestCount,
				"error_count":   s.stats.ErrorCount,
				"memory_usage":  fmt.Sprintf("%.2f MB", float64(s.stats.MemoryUsage)/1024/1024),
				"goroutines":    runtime.NumGoroutine(),
				"start_time":    s.stats.StartTime.Format("2006-01-02 15:04:05"),
			},
		})
	})

	// 测试路由
	app.Get("/test", func(c *fiber.Ctx) error {
		return c.JSON(fiber.Map{
			"message":  "Test route works!",
			"data_dir": s.DataDir,
		})
	})

	// 注册文件处理器
	fileHandler := api.NewFileHandler(s.DataDir)
	fileHandler.RegisterRoutes(app)

	// 直接添加文件访问路由（备用方案）
	app.Get("/api/files/*", func(c *fiber.Ctx) error {
		filePath := c.Params("*")
		log.Printf("🔍 直接路由 - 请求文件: %s", filePath)
		log.Printf("🔍 直接路由 - 数据目录: %s", s.DataDir)

		if filePath == "" {
			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
				"code": 400,
				"data": "文件路径不能为空",
			})
		}

		fullPath := filepath.Join(s.DataDir, filePath)
		log.Printf("🔍 直接路由 - 完整文件路径: %s", fullPath)

		// 检查文件是否存在
		if _, err := os.Stat(fullPath); os.IsNotExist(err) {
			log.Printf("❌ 直接路由 - 文件不存在: %s", fullPath)
			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
				"code": 404,
				"data": "文件不存在",
			})
		}

		log.Printf("✅ 直接路由 - 返回文件: %s", fullPath)
		return c.SendFile(fullPath)
	})

	log.Printf("📋 文件 API 端点:")
	log.Printf("  - GET    /api/files/*")
	log.Printf("  - POST   /api/files")
	log.Printf("  - GET    /debug/data-dir")

	s.app = app

	log.Printf("🚀 启动 HTTPS API 服务器，端口: %d", s.port)
	log.Printf("📡 服务器地址: https://0.0.0.0:%d", s.port)
	log.Printf("🌐 监听所有网络接口，允许局域网访问")
	log.Printf("📋 可用的 API 端点:")
	log.Printf("  - GET    /api/cards")
	log.Printf("  - GET    /api/cards/{id}")
	log.Printf("  - POST   /api/cards")
	log.Printf("  - PUT    /api/cards/{id}")
	log.Printf("  - DELETE /api/cards/{id}")
	log.Printf("  - GET    /api/images/*")
	log.Printf("  - GET    /api/audio/*")
	log.Printf("  - GET    /health")
	log.Printf("  - GET    /api/sync")
	log.Printf("  - GET    /stats")

	// 自动生成证书
	certFile := filepath.Join(s.DataDir, "cert.pem")
	keyFile := filepath.Join(s.DataDir, "key.pem")
	if err := ensureCert(certFile, keyFile); err != nil {
		return fmt.Errorf("自动生成证书失败: %w", err)
	}

	// 启动 HTTPS 服务器
	return app.ListenTLS(fmt.Sprintf(":%d", s.port), certFile, keyFile)
}

// Stop 停止服务器
func (s *HTTPSServer) Stop() error {
	log.Println("🛑 停止 HTTPS API 服务器")

	if s.server != nil {
		if err := s.server.Close(); err != nil {
			return fmt.Errorf("关闭服务器失败: %w", err)
		}
	}

	if s.repo != nil {
		if err := s.repo.Close(); err != nil {
			return fmt.Errorf("关闭数据库失败: %w", err)
		}
	}

	// 输出最终统计信息
	s.printFinalStats()

	return nil
}

// SetUDPDiscovery 设置UDP发现服务
func (s *HTTPSServer) SetUDPDiscovery(udpDiscovery interface{}) {
	s.udpDiscovery = udpDiscovery
	// 更新CardHandler的UDP发现服务引用
	if s.handler != nil {
		// 通过反射设置CardHandler的udpDiscovery字段
		handlerValue := reflect.ValueOf(s.handler).Elem()
		udpField := handlerValue.FieldByName("udpDiscovery")
		if udpField.IsValid() && udpField.CanSet() {
			udpField.Set(reflect.ValueOf(udpDiscovery))
			log.Printf("✅ UDP发现服务已设置到CardHandler")
		}
	}
}

// monitorPerformance 性能监控
func (s *HTTPSServer) monitorPerformance() {
	ticker := time.NewTicker(30 * time.Second) // 每30秒监控一次
	defer ticker.Stop()

	for range ticker.C {
		var m runtime.MemStats
		runtime.ReadMemStats(&m)

		log.Printf("📊 性能监控 - 内存使用: %.2f MB, Goroutines: %d, 请求数: %d, 错误数: %d",
			float64(m.Alloc)/1024/1024,
			runtime.NumGoroutine(),
			s.stats.RequestCount,
			s.stats.ErrorCount,
		)
	}
}

// printFinalStats 打印最终统计信息
func (s *HTTPSServer) printFinalStats() {
	uptime := time.Since(s.stats.StartTime)
	var m runtime.MemStats
	runtime.ReadMemStats(&m)

	log.Printf("📊 服务器最终统计:")
	log.Printf("  - 运行时间: %v", uptime)
	log.Printf("  - 总请求数: %d", s.stats.RequestCount)
	log.Printf("  - 错误数: %d", s.stats.ErrorCount)
	log.Printf("  - 内存使用: %.2f MB", float64(m.Alloc)/1024/1024)
	log.Printf("  - Goroutines: %d", runtime.NumGoroutine())
}

// createTLSConfig 创建 TLS 配置
func (s *HTTPSServer) createTLSConfig() (*tls.Config, error) {
	// 证书文件路径
	certFile := filepath.Join(s.DataDir, "certificate.crt")
	keyFile := filepath.Join(s.DataDir, "private.key")

	// 检查证书文件是否存在
	if _, err := os.Stat(certFile); os.IsNotExist(err) {
		return nil, fmt.Errorf("证书文件不存在: %s", certFile)
	}

	if _, err := os.Stat(keyFile); os.IsNotExist(err) {
		return nil, fmt.Errorf("私钥文件不存在: %s", keyFile)
	}

	// 加载证书
	cert, err := tls.LoadX509KeyPair(certFile, keyFile)
	if err != nil {
		return nil, fmt.Errorf("加载证书失败: %w", err)
	}

	// 创建 TLS 配置
	config := &tls.Config{
		Certificates: []tls.Certificate{cert},
		MinVersion:   tls.VersionTLS12,
	}

	return config, nil
}

// ensureCert 检查并自动生成自签名证书
func ensureCert(certFile, keyFile string) error {
	if _, err := os.Stat(certFile); err == nil {
		if _, err := os.Stat(keyFile); err == nil {
			return nil // 都存在
		}
	}
	// 生成自签名证书
	priv, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		return err
	}
	template := x509.Certificate{
		SerialNumber:          big.NewInt(1),
		Subject:               pkix.Name{CommonName: "localhost"},
		NotBefore:             time.Now(),
		NotAfter:              time.Now().Add(10 * 365 * 24 * time.Hour),
		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
		BasicConstraintsValid: true,
		DNSNames:              []string{"localhost"},
	}
	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
	if err != nil {
		return err
	}
	certOut, err := os.Create(certFile)
	if err != nil {
		return err
	}
	defer certOut.Close()
	pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
	keyOut, err := os.Create(keyFile)
	if err != nil {
		return err
	}
	defer keyOut.Close()
	pem.Encode(keyOut, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)})
	return nil
}
